home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 329_01 / regexp.c < prev    next >
C/C++ Source or Header  |  1989-01-04  |  29KB  |  1,214 lines
  1. /*
  2.  * regcomp and regexec -- regsub and regerror are elsewhere
  3.  *
  4.  *    Copyright (c) 1986 by University of Toronto.
  5.  *    Written by Henry Spencer.  Not derived from licensed software.
  6.  *
  7.  *    Permission is granted to anyone to use this software for any
  8.  *    purpose on any computer system, and to redistribute it freely,
  9.  *    subject to the following restrictions:
  10.  *
  11.  *    1. The author is not responsible for the consequences of use of
  12.  *        this software, no matter how awful, even if they arise
  13.  *        from defects in it.
  14.  *
  15.  *    2. The origin of this software must not be misrepresented, either
  16.  *        by explicit claim or by omission.
  17.  *
  18.  *    3. Altered versions must be plainly marked as such, and must not
  19.  *        be misrepresented as being the original software.
  20.  *
  21.  * Beware that some of this code is subtly aware of the way operator
  22.  * precedence is structured in regular expressions.  Serious changes in
  23.  * regular-expression syntax might require a total rethink.
  24.  */
  25. #include <stdio.h>
  26. #include "regexp.h"
  27. #include "regmagic.h"
  28.  
  29. /*
  30.  * The "internal use only" fields in regexp.h are present to pass info from
  31.  * compile to execute that permits the execute phase to run lots faster on
  32.  * simple cases.  They are:
  33.  *
  34.  * regstart    char that must begin a match; '\0' if none obvious
  35.  * reganch    is the match anchored (at beginning-of-line only)?
  36.  * regmust    string (pointer into program) that match must include, or NULL
  37.  * regmlen    length of regmust string
  38.  *
  39.  * Regstart and reganch permit very fast decisions on suitable starting points
  40.  * for a match, cutting down the work a lot.  Regmust permits fast rejection
  41.  * of lines that cannot possibly match.  The regmust tests are costly enough
  42.  * that regcomp() supplies a regmust only if the r.e. contains something
  43.  * potentially expensive (at present, the only such thing detected is * or +
  44.  * at the start of the r.e., which can involve a lot of backup).  Regmlen is
  45.  * supplied because the test in regexec() needs it and regcomp() is computing
  46.  * it anyway.
  47.  */
  48.  
  49. /*
  50.  * Structure for regexp "program".  This is essentially a linear encoding
  51.  * of a nondeterministic finite-state machine (aka syntax charts or
  52.  * "railroad normal form" in parsing technology).  Each node is an opcode
  53.  * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
  54.  * all nodes except BRANCH implement concatenation; a "next" pointer with
  55.  * a BRANCH on both ends of it is connecting two alternatives.  (Here we
  56.  * have one of the subtle syntax dependencies:  an individual BRANCH (as
  57.  * opposed to a collection of them) is never concatenated with anything
  58.  * because of operator precedence.)  The operand of some types of node is
  59.  * a literal string; for others, it is a node leading into a sub-FSM.  In
  60.  * particular, the operand of a BRANCH node is the first node of the branch.
  61.  * (NB this is *not* a tree structure:  the tail of the branch connects
  62.  * to the thing following the set of BRANCHes.)  The opcodes are:
  63.  */
  64.  
  65. /* definition    number    opnd?    meaning */
  66. #define    END    0    /* no    End of program. */
  67. #define    BOL    1    /* no    Match "" at beginning of line. */
  68. #define    EOL    2    /* no    Match "" at end of line. */
  69. #define    ANY    3    /* no    Match any one character. */
  70. #define    ANYOF    4    /* str    Match any character in this string. */
  71. #define    ANYBUT    5    /* str    Match any character not in this string. */
  72. #define    BRANCH    6    /* node    Match this alternative, or the next... */
  73. #define    BACK    7    /* no    Match "", "next" ptr points backward. */
  74. #define    EXACTLY    8    /* str    Match this string. */
  75. #define    NOTHING    9    /* no    Match empty string. */
  76. #define    STAR    10    /* node    Match this (simple) thing 0 or more times. */
  77. #define    PLUS    11    /* node    Match this (simple) thing 1 or more times. */
  78. #define    OPEN    20    /* no    Mark this point in input as start of #n. */
  79.             /*    OPEN+1 is number 1, etc. */
  80. #define    CLOSE    30    /* no    Analogous to OPEN. */
  81.  
  82. /*
  83.  * Opcode notes:
  84.  *
  85.  * BRANCH    The set of branches constituting a single choice are hooked
  86.  *        together with their "next" pointers, since precedence prevents
  87.  *        anything being concatenated to any individual branch.  The
  88.  *        "next" pointer of the last BRANCH in a choice points to the
  89.  *        thing following the whole choice.  This is also where the
  90.  *        final "next" pointer of each individual branch points; each
  91.  *        branch starts with the operand node of a BRANCH node.
  92.  *
  93.  * BACK        Normal "next" pointers all implicitly point forward; BACK
  94.  *        exists to make loop structures possible.
  95.  *
  96.  * STAR,PLUS    '?', and complex '*' and '+', are implemented as circular
  97.  *        BRANCH structures using BACK.  Simple cases (one character
  98.  *        per match) are implemented with STAR and PLUS for speed
  99.  *        and to minimize recursive plunges.
  100.  *
  101.  * OPEN,CLOSE    ...are numbered at compile time.
  102.  */
  103.  
  104. /*
  105.  * A node is one char of opcode followed by two chars of "next" pointer.
  106.  * "Next" pointers are stored as two 8-bit pieces, high order first.  The
  107.  * value is a positive offset from the opcode of the node containing it.
  108.  * An operand, if any, simply follows the node.  (Note that much of the
  109.  * code generation knows about this implicit relationship.)
  110.  *
  111.  * Using two bytes for the "next" pointer is vast overkill for most things,
  112.  * but allows patterns to get big without disasters.
  113.  */
  114. #define    OP(p)    (*(p))
  115. #define    NEXT(p)    (((*((p)+1)&0377)<<8) + *((p)+2)&0377)
  116. #define    OPERAND(p)    ((p) + 3)
  117.  
  118. /*
  119.  * See regmagic.h for one further detail of program structure.
  120.  */
  121.  
  122.  
  123. /*
  124.  * Utility definitions.
  125.  */
  126. #ifndef CHARBITS
  127. #define    UCHARAT(p)    ((int)*(unsigned char *)(p))
  128. #else
  129. #define    UCHARAT(p)    ((int)*(p)&CHARBITS)
  130. #endif
  131.  
  132. #define    FAIL(m)    { regerror(m); return(NULL); }
  133. #define    ISMULT(c)    ((c) == '*' || (c) == '+' || (c) == '?')
  134. #define    META    "^$.[()|?+*\\"
  135.  
  136. /*
  137.  * Flags to be passed up and down.
  138.  */
  139. #define    HASWIDTH    01    /* Known never to match null string. */
  140. #define    SIMPLE        02    /* Simple enough to be STAR/PLUS operand. */
  141. #define    SPSTART        04    /* Starts with * or +. */
  142. #define    WORST        0    /* Worst case. */
  143.  
  144. /*
  145.  * Global work variables for regcomp().
  146.  */
  147. static char *regparse;        /* Input-scan pointer. */
  148. static int regnpar;        /* () count. */
  149. static char regdummy;
  150. static char *regcode;        /* Code-emit pointer; ®dummy = don't. */
  151. static long regsize;        /* Code size. */
  152.  
  153. /*
  154.  * Forward declarations for regcomp()'s friends.
  155.  */
  156. #ifndef STATIC
  157. #define    STATIC    static
  158. #endif
  159. STATIC char *reg();
  160. STATIC char *regbranch();
  161. STATIC char *regpiece();
  162. STATIC char *regatom();
  163. STATIC char *regnode();
  164. STATIC char *regnext();
  165. STATIC void regc();
  166. STATIC void reginsert();
  167. STATIC void regtail();
  168. STATIC void regoptail();
  169. #ifdef STRCSPN
  170. STATIC int strcspn();
  171. #endif
  172.  
  173. /*
  174.  - regcomp - compile a regular expression into internal code
  175.  *
  176.  * We can't allocate space until we know how big the compiled form will be,
  177.  * but we can't compile it (and thus know how big it is) until we've got a
  178.  * place to put the code.  So we cheat:  we compile it twice, once with code
  179.  * generation turned off and size counting turned on, and once "for real".
  180.  * This also means that we don't allocate space until we are sure that the
  181.  * thing really will compile successfully, and we never have to move the
  182.  * code and thus invalidate pointers into it.  (Note that it has to be in
  183.  * one piece because free() must be able to free it all.)
  184.  *
  185.  * Beware that the optimization-preparation code in here knows about some
  186.  * of the structure of the compiled regexp.
  187.  */
  188. regexp *
  189. regcomp(exp)
  190. char *exp;
  191. {
  192.     register regexp *r;
  193.     register char *scan;
  194.     register char *longest;
  195.     register int len;
  196.     int flags;
  197.     extern void *malloc();
  198.  
  199.     if (exp == NULL)
  200.         FAIL("NULL argument");
  201.  
  202.     /* First pass: determine size, legality. */
  203.     regparse = exp;
  204.     regnpar = 1;
  205.     regsize = 0L;
  206.     regcode = ®dummy;
  207.     regc(MAGIC);
  208.     if (reg(0, &flags) == NULL)
  209.         return(NULL);
  210.  
  211.     /* Small enough for pointer-storage convention? */
  212.     if (regsize >= 32767L)        /* Probably could be 65535L. */
  213.         FAIL("regexp too big");
  214.  
  215.     /* Allocate space. */
  216.     r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize);
  217.     if (r == NULL)
  218.         FAIL("out of space");
  219.  
  220.     /* Second pass: emit code. */